FEXPGeom.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Library for geometry.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPGEOM_H_
#define _CFEXPGEOM_H_
#include "FEXPCommon.h"
#include "FEXPSerialization.h"

namespace FEXPFEGeom
{
  enum EFEXPFECoordinates
  {
    eC_x = 0,
    eC_y,
    eC_z,
    eC_Count
  };

  enum EFEXPFENaturalCoordinates
  {
    eXi = 0,
    eEta,
    ePsi,
    eNatC_Count
  };
}

// primary template
template<typename TValue, typename Enable = void>
class ICFEXPFECoordinatesBase { };
template<typename TValue>
class ICFEXPFECoordinatesBase
  // specialization to floating point types
  <TValue, typename std::enable_if<std::is_floating_point<TValue>::value>::type>
{
public:
  ICFEXPFECoordinatesBase() { }
  virtual ~ICFEXPFECoordinatesBase() { }

  // pure virtual member functions
  virtual Ptr<TValue> GetCoordArray() = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#define DEFAULT_COORD_ID -1
#define COORD_ERROR "Error: Wrong coordinate identifier!!!"
#define COORD_OPTIMIZATION_IS_ON 0

template<typename TValue>
class CFEXPFECoordinates :
  public ICFEXPFECoordinatesBase<TValue>
{
public:
  CFEXPFECoordinates();
  CFEXPFECoordinates(size_t id);
  CFEXPFECoordinates(size_t id, TValue cx, TValue cy, TValue cz);
  CFEXPFECoordinates(size_t id, const std::vector<TValue> & coords);
  CFEXPFECoordinates(const CFEXPFECoordinates<TValue> & source);
  virtual ~CFEXPFECoordinates() { }

  virtual TValue GetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord) const;
  virtual void   SetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord, TValue value);
  virtual size_t GetNodeId();
  virtual void   SetNodeId(size_t id);

  // override base virtual functions
  virtual Ptr<TValue> GetCoordArray() override;
protected:
  // [no protected members] -----------------------------
private:
  size_t              _coordinate_id;
#if !COORD_OPTIMIZATION_IS_ON
  std::vector<TValue> _coordinates;
#else
  Ptr<TValue> _coordinates;
#endif
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPFECoordinates<TValue>
  ::CFEXPFECoordinates()
  : _coordinate_id(DEFAULT_COORD_ID)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates.resize(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#else
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPFECoordinates<TValue>
  ::CFEXPFECoordinates(size_t id)
  : _coordinate_id(id)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates.resize(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#else
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPFECoordinates<TValue>
  ::CFEXPFECoordinates(size_t id, TValue cx, TValue cy, TValue cz)
  : _coordinate_id(id)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates.resize(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#else
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#endif
  SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x, cx);
  SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y, cy);
  SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z, cz);
}

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPFECoordinates<TValue>
  ::CFEXPFECoordinates(size_t id, const std::vector<TValue> & coords)
  : _coordinate_id(id)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates.resize(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#else
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
#endif
  size_t cntr = 0;
  FEXPCOMMON_FOREACH_ITER(coords)
    SetCoordinate((FEXPFEGeom::EFEXPFECoordinates)(cntr++), *IT);
}

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPFECoordinates<TValue>
  ::CFEXPFECoordinates(const CFEXPFECoordinates<TValue> & source)
  : _coordinate_id(source._coordinate_id)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates = source._coordinates;
#else
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(FEXPFEGeom::EFEXPFECoordinates::eC_Count);
  size_t cntr;
  FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, FEXPFEGeom::EFEXPFECoordinates::eC_Count, cntr)
  {
    auto coord = (FEXPFEGeom::EFEXPFECoordinates)(cntr++);
    SetCoordinate(coord, source.GetCoordinate(coord));
  }
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
TValue CFEXPFECoordinates<TValue>
  ::GetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord) const
//--------------------------------------------------------------------------------------
{
  if (coord == FEXPFEGeom::EFEXPFECoordinates::eC_Count)
    FEXPCOMMON_EXCEPTION(COORD_ERROR);

#if !COORD_OPTIMIZATION_IS_ON
  return _coordinates[coord];
#else
  return _coordinates.get()[coord];
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEXPFECoordinates<TValue>
  ::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord, TValue value)
//--------------------------------------------------------------------------------------
{
  if (coord == FEXPFEGeom::EFEXPFECoordinates::eC_Count)
    FEXPCOMMON_EXCEPTION(COORD_ERROR);

#if !COORD_OPTIMIZATION_IS_ON
  _coordinates[coord] = value;
#else
  _coordinates.get()[coord] = value;
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
size_t CFEXPFECoordinates<TValue>
  ::GetNodeId()
//--------------------------------------------------------------------------------------
{
  return _coordinate_id;
}

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEXPFECoordinates<TValue>
  ::SetNodeId(size_t id)
//--------------------------------------------------------------------------------------
{
  _coordinate_id = id;
}

//--------------------------------------------------------------------------------------
template<typename TValue>
Ptr<TValue> CFEXPFECoordinates<TValue>
  ::GetCoordArray()
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  auto coord_array = CFEXPDataManager<TValue>::SafeAllocInstanceArray(_coordinates.size());
  std::copy(_coordinates.begin(), _coordinates.end(), coord_array.get());
  return coord_array;
#else
  return _coordinates;
#endif
}


template <typename TValue>
class CFEXPVector
  : public CFEXPFECoordinates<TValue>
{
public:
  CFEXPVector(size_t id);
  CFEXPVector(size_t id, TValue x, TValue y, TValue z);
  CFEXPVector(size_t id, Ptr<CFEXPFECoordinates<TValue>> crd1, Ptr<CFEXPFECoordinates<TValue>> crd2);
  virtual ~CFEXPVector() { }

  void SetVector(TValue x , TValue y , TValue z);
  void SetVector(TValue x1, TValue y1, TValue z1, TValue x2, TValue y2, TValue z2);
  virtual void SetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord, TValue value) override;
protected:
  // [no protected members] -----------------------------
private:
  void create_vector(TValue x, TValue y, TValue z);
  void normalize    ();
};

// member functions
//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPVector<TValue>
::CFEXPVector(size_t id)
  : CFEXPFECoordinates<TValue>(id) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPVector<TValue>
::CFEXPVector(size_t id, TValue x, TValue y, TValue z)
  : CFEXPFECoordinates<TValue>(id)
//--------------------------------------------------------------------------------------
{
  SetVector(x, y, z);
}

//--------------------------------------------------------------------------------------
template <typename TValue>
CFEXPVector<TValue>
  ::CFEXPVector(size_t id, Ptr<CFEXPFECoordinates<TValue>> crd1, Ptr<CFEXPFECoordinates<TValue>> crd2)
  : CFEXPFECoordinates<TValue>(id)
//--------------------------------------------------------------------------------------
{
  create_vector(crd2->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) - crd1->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x),
                crd2->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) - crd1->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y),
                crd2->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) - crd1->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z));
}

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPVector<TValue>
  ::SetVector(TValue x, TValue y, TValue z)
//--------------------------------------------------------------------------------------
{
  create_vector(x, y, z);
}

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPVector<TValue>
  ::SetVector(TValue x1, TValue y1, TValue z1, TValue x2, TValue y2, TValue z2)
//--------------------------------------------------------------------------------------
{
  create_vector(x2 - x1, y2 - y1, z2 - z1);
}

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPVector<TValue>
  ::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates coord, TValue value)
//--------------------------------------------------------------------------------------
{
  CFEXPFECoordinates<TValue>::SetCoordinate(coord, value);
  normalize();
}

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPVector<TValue>::create_vector(TValue x, TValue y, TValue z)
//--------------------------------------------------------------------------------------
{
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x, x);
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y, y);
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z, z);
  normalize();
}

//--------------------------------------------------------------------------------------
template <typename TValue>
void CFEXPVector<TValue>::normalize()
//--------------------------------------------------------------------------------------
{
  // Normalize process:
  // 1. calculate length of vector
  auto length = sqrt(pow(GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x), 2) +
                     pow(GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y), 2) +
                     pow(GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z), 2));
  // 2. normalize vector
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x, GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) / length);
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y, GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) / length);
  CFEXPFECoordinates<TValue>::SetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z, GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) / length);
}


template<typename TValue>
class CFEX3DPlane
{
public:
  CFEX3DPlane(size_t id,
    const Ptr<CFEXPFECoordinates<TValue>> & nd1,
    const Ptr<CFEXPFECoordinates<TValue>> & nd2, 
    const Ptr<CFEXPFECoordinates<TValue>> & nd3);
  virtual ~CFEX3DPlane() { }

  Ptr<CFEXPVector<TValue>> & GetVector(FEXPFEGeom::EFEXPFECoordinates coord);
protected:
  // [no protected members] -----------------------------
private:
  size_t                                _id;
  std::vector<Ptr<CFEXPVector<TValue>>> _plane;
  void create_plane(size_t id,
    const Ptr<CFEXPFECoordinates<TValue>> & nd1,
    const Ptr<CFEXPFECoordinates<TValue>> & nd2,
    const Ptr<CFEXPFECoordinates<TValue>> & nd3);
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TValue>
CFEX3DPlane<TValue>::CFEX3DPlane(size_t id,
  const Ptr<CFEXPFECoordinates<TValue>> & nd1,
  const Ptr<CFEXPFECoordinates<TValue>> & nd2,
  const Ptr<CFEXPFECoordinates<TValue>> & nd3)
//--------------------------------------------------------------------------------------
{
  create_plane(id, nd1, nd2, nd3);
}

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEX3DPlane<TValue>::create_plane(size_t id,
  const Ptr<CFEXPFECoordinates<TValue>> & nd1,
  const Ptr<CFEXPFECoordinates<TValue>> & nd2,
  const Ptr<CFEXPFECoordinates<TValue>> & nd3)
//--------------------------------------------------------------------------------------
{
  _plane.clear();
  _id         = id;
  // x axis
  auto vect_x = CFEXPDataManager<CFEXPVector<TValue>>::SafeAllocInstance(0, nd1, nd2);
  // y axis
  auto vect_y = CFEXPDataManager<CFEXPVector<TValue>>::SafeAllocInstance(1, nd2, nd3);
  // z axis
  // x-coordinate
  auto valu_x = (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z)) -
                (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y));
  // y-coordinate
  auto valu_y = (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x)) -
                (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z));
  // z-coordinate
  auto valu_z = (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y)) -
                (vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) * vect_y->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x));
  auto vect_z = CFEXPDataManager<CFEXPVector<TValue>>::SafeAllocInstance(2, valu_x, valu_y, valu_z);

  // correction of vector of y axis
  // x-coordinate
  valu_x = (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z)) -
           (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y));
  // y-coordinate
  valu_y = (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x)) -
           (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_z));
  // z-coordinate
  valu_z = (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y)) -
           (vect_z->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_y) * vect_x->GetCoordinate(FEXPFEGeom::EFEXPFECoordinates::eC_x));
  vect_y->SetVector(valu_x, valu_y, valu_z);
  // create plane
  _plane = { vect_x, vect_y, vect_z };
}

//--------------------------------------------------------------------------------------
template<typename TValue>
Ptr<CFEXPVector<TValue>> & CFEX3DPlane<TValue>::GetVector(FEXPFEGeom::EFEXPFECoordinates coord)
//--------------------------------------------------------------------------------------
{
  return _plane[coord];
}

// default ratio for wideing of a bounding box
#define DEFAULT_BB_RATIO 1.0 / 10.0

class CFEXGeomTools
{
public:
  enum EBoundingBox { eMin, eMax };
  using t_BoundBox = std::map<EBoundingBox, Ptr<CFEXPFECoordinates<t_fexpcommon_ct>>>;
  static Ptr<t_BoundBox> GetBoundingBox(Ptr<CFEXGeomTools::t_BoundBox> current_bb, Ptr<CFEXPFECoordinates<t_fexpcommon_ct>> item_to_check);
  static Ptr<t_BoundBox> ExtBoundingBox(Ptr<CFEXGeomTools::t_BoundBox> current_bb, t_fexpcommon_ct ratio);
  // bounding box serialization
  static Ptr<t_SerializedData> GetSerializedBoundingBox  (Ptr<t_BoundBox> bb);
  static Ptr<t_BoundBox>       GetDeserializedBoundingBox(Ptr<t_SerializedData> bb);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

template<typename TValue>
using t_MacroModelMap = std::map<size_t,
  std::vector<std::tuple<size_t, Ptr<CFEXGeomTools::t_BoundBox>>>>;

#endif // !_CFEXPGEOM_H_